package com.itheima.service;

import com.alibaba.dubbo.config.annotation.Service;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.itheima.constant.MessageConstant;
import com.itheima.dao.PermissionDao;
import com.itheima.dao.RoleDao;
import com.itheima.dao.UserDao;
import com.itheima.entity.PageResult;
import com.itheima.entity.QueryPageBean;
import com.itheima.entity.Result;
import com.itheima.pojo.Permission;
import com.itheima.pojo.Role;
import com.itheima.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 用户服务
 */
@Service(interfaceClass = UserService.class)
@Transactional
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDao userDao;
    @Autowired
    private RoleDao roleDao;
    @Autowired
    private PermissionDao permissionDao;
    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;
    //根据用户名查询用户信息,包括用户的角色和角色关联的权限
    public User findByUsername(String username) {
        User user = userDao.findByUsername(username);//根据用户名查询用户表
        if(user == null){
            return null;
        }
        Integer userId = user.getId();
        //根据用户id查询关联的角色
        Set<Role> roles = roleDao.findByUserId(userId);
        if(roles != null && roles.size() > 0){
            //遍历角色集合，查询每个角色关联的权限
            for (Role role : roles) {
                Integer roleId = role.getId();//角色id
                //根据角色id查询关联的权限
                Set<Permission> permissions = permissionDao.findPermissionById(roleId);
                if(permissions != null && permissions.size() > 0){
                    //角色关联权限集合
                    role.setPermissions(permissions);
                }
            }
            //用户关联角色集合
            user.setRoles(roles);
        }

        return user;
    }
    /**
     * 分页查询用户基本信息
     *
     * @param queryPageBean
     * @return
     */
    @Override
    public PageResult findUserByPage(QueryPageBean queryPageBean) {
        Integer currentPage = queryPageBean.getCurrentPage();
        Integer pageSize = queryPageBean.getPageSize();
        PageHelper.startPage(currentPage, pageSize);
//        对用户查询的字段进行去空格处理
        String queryString = queryPageBean.getQueryString();
        if (queryString != null && queryString.contains(" ")) {
            queryString = queryString.replaceAll(" ", "");
        }
        Page<User> page = userDao.findUserByPage(queryString);
        return new PageResult(page.getTotal(), page.getResult());
    }

    /*
     * 添加用户
     * @param user
     * @param roleIds
     */
    @Override
    public Result add(User user, Integer[] roleIds) {
//        判断用户是否存在
        User user1 = userDao.findExist(user);
        if (user1 != null) {
            return new Result(false, MessageConstant.ADD_USER_FAIL, "用户已经存在");
        }
        //对用户密码进行加密
        //            对user的密码进行加密
        String password = bCryptPasswordEncoder.encode(user.getPassword());
        user.setPassword(password);
        userDao.add(user);
//        添加用户和角色的对应关系
        for (Integer roleId : roleIds) {
            userDao.addRele(user.getId(), roleId);
        }
        return new Result(true, MessageConstant.ADD_USER_SUCCESS);
    }



    /**
     * 修改密码
     *
     * @param map
     * @return
     */
    @Override
    public Result modifyPassword(Map map) {
        String oldPassword = (String) map.get("oldPassword");
        String username = (String) map.get("username");
        String password = (String) map.get("password");
        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
//        1.比对原密码是否一样
        String passwordByUser = userDao.findPasswordByUser(user);
//        对passwordByUser进行解密比对
        boolean matches = bCryptPasswordEncoder.matches(oldPassword, passwordByUser);
        if (!matches) {
            return new Result(false, MessageConstant.UPDATE_PASSWORD_FAIL, "原密码输入错误");
        }
//        对密码进行加密
        password = bCryptPasswordEncoder.encode(password);
        user.setPassword(password);
//        修改密码
        userDao.updatePassword(user);
        return new Result(true, MessageConstant.UPDATE_PASSWORD_SUCCESS);
    }

    /**
     * 编辑回显数据
     * @param id
     * @return
     */
    @Override
    public Map findUserById(Integer id) {
//       根据用户id查询 用户的基本信息
        User formData = userDao.findUserBaseById(id);
//        查询所有的角色信息
        List<Role> tableData = roleDao.findAll();
//        根据用户的id 查询用户对应的角色id
        List<Integer> roleIds = roleDao.findRole(id);
        Map<String,Object> map=new HashMap<>();
        map.put("formData",formData);
        map.put("roleIds",roleIds);
        map.put("tableData",tableData);
        return map;
    }

    /**
     * 编辑用户信息
     * @param user
     * @param roleIds
     */
    @Override
    public void edit(User user, Integer[] roleIds) {
//        编辑用户表
        userDao.editUser(user);
//        编辑用户从属角色表
        if (roleIds!=null||roleIds.length>0) {
            //    删除对应的从属关系
            userDao.dele(user.getId());
            for (Integer roleId : roleIds) {
//                添加从属关系
                userDao.addRele(user.getId(), roleId);
            }
        }
    }

    /**
     * 删除用户
     * @param id
     */
    @Override
    public Result deleteUser(Integer id) {
//     判断删除的用户是否存在管理员角色
        Set<Role> roles = roleDao.findByUserId(id);
        for (Role role : roles) {
            if (role.getKeyword().equals("ROLE_ADMIN")) {
                return new Result(false,MessageConstant.DEL_USER_FAIL,"该用户为系统管理员不可删除");
            }
        }
//        删除从属关系
        userDao.dele(id);
//        删除用户
        userDao.removeUser(id);
        return new Result(true,MessageConstant.DEL_USER_SUCCESS);
    }
}
